package com.ctl.juc.queue;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * 用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下
 * 不保证访问者公平的访问队列，所谓公平访问队列是指阻塞的所有生产者线程或消费者线程，当
 * 队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入
 * 元素，先阻塞的消费者线程，可以先从队列里获取元素。通常情况下为了保证公平性会降低吞吐
 * 量。
 */
public class ArrayBlockingQueueTest {
    private volatile static  int i=0;
    private volatile static  int j=0;
    private volatile static  int m=1111;
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<Integer> fairQueue = new ArrayBlockingQueue(10,false);
        new Thread(()->{
            for (int k = 0; k <100 ; k++) {
                    fairQueue.add(m++);
            }
        }).start();
        new Thread(()->{
            for (int k = 0; k <100 ; k++) {
                try {
                    fairQueue.put(i++);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            for (int k = 0; k <100 ; k++) {
                try {
                    fairQueue.put(j--);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(()->{
            for (int k = 0; k <100 ; k++) {
                try {
                    Integer i=fairQueue.take();
                    System.out.println(i);
                } catch (InterruptedException e) {

                }
            }
        }).start();

        for (int k = 0; k <100 ; k++) {
            try {
                Integer i=fairQueue.take();
                System.out.println(i);
            } catch (InterruptedException e) {

            }
        }
        Thread.sleep(2000);
    }
}
